
# Verificação da versão do Python
from platform import python_version
print('Versão do Python: ', python_version())

Versão do Python:  3.11.2


# Imports das bibliotecas mais usadas
import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt

%matplotlib inline


import tensorflow as tf
from tensorflow.keras import datasets, layers, models
from PIL import Image


# suppress warnings from final output
# Oculta alguns alertas
import warnings
warnings.simplefilter("ignore")


# Silencia mensagens do TF
%env TF_CPP_MIN_LOG_LEVEL=3

env: TF_CPP_MIN_LOG_LEVEL=3


# Alterar a exibição de float para duas casas decimais
#pd.options.display.float_format = '{:20,.2f}'.format
pd.options.display.float_format = '{:.4f}'.format
# pd.set_option("precision", 2)
#np.set_printoptions(precision=2)


# Versões das bibliotecas usadas
print('Numpy versão ' + np.__version__)
print('Pandas versão ' + pd.__version__)
print('Matplotlib versão ' + mpl.__version__)
print('TensorFlow versão ' + tf.__version__)

Numpy versão 1.23.5
Pandas versão 2.0.0
Matplotlib versão 3.7.1
TensorFlow versão 2.12.0


# Carrega o dataset CIFAR-10
(imagens_treino, labels_treino), (imagens_teste, labels_teste) = datasets.cifar10.load_data()


# Exibe as dimensões dos dados
print('Dimensões de Imagens de Treino:', imagens_treino.shape)
print('Dimensões de Label de Treino:', labels_treino.shape)
print('Dimensões de Imagens de Teste:', imagens_teste.shape)
print('Dimensões de Labels de Teste:', labels_teste.shape)

Dimensões de Imagens de Treino: (50000, 32, 32, 3)
Dimensões de Label de Treino: (50000, 1)
Dimensões de Imagens de Teste: (10000, 32, 32, 3)
Dimensões de Labels de Teste: (10000, 1)


# Valor das classes (labels)
classes = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']


# Tradução para o valor das classes (labels)
traducao_classes = {'airplane': 'avião' , 'automobile': 'automóvel', 'bird': 'pássaro', 'cat':'gato', 'deer': 'veado',
                   'dog': 'cão', 'frog': 'sapo', 'horse': 'cavalo', 'ship': 'navio', 'truck': 'caminhão'}


# Constante para normalizar pixels
VALOR_NORMALIZACAO_PIXEL = 255.0


# Normaliza os valores dos pixels para que os dados fiquem na mesma escala
imagens_treino = imagens_treino / VALOR_NORMALIZACAO_PIXEL
imagens_teste = imagens_teste / VALOR_NORMALIZACAO_PIXEL


# Função para exibir as imagens e labels
def visualizar_imagens_labels(imagens, labels, classes):
    plt.figure(figsize = (10,10))
    for i in range(25):
        plt.subplot(5, 5, i+1)
        plt.xticks([])
        plt.yticks([])
        plt.grid(False)
        plt.imshow(imagens[i], cmap = plt.cm.binary)
        plt.xlabel(classes[labels[i][0]])
    plt.show()


# Exibe as imagens e labels de treino
visualizar_imagens_labels(imagens_treino, labels_treino, classes)


# Extrair as dimensões das imagens
assert imagens_treino.shape[1:] == imagens_teste.shape[1:]
DIMENSAO_IMAGEM = imagens_treino.shape[1:]
DIMENSAO_IMAGEM

(32, 32, 3)


# Constantes para parâmetros das funções do modelo
CONV2D_FILTERS_1 = 32
CONV2D_FILTERS_2 = 64
CONV2D_KERNEL_SIZE = (3, 3)
POOL_SIZE = (2, 2)
DENSE_UNITS_1 = 64
DENSE_UNITS_2 = 10


# Cria o modelo sequencial de camadas
modelo = models.Sequential()


# Camada de Entrada - Primeiro bloco de convolução e max pooling
modelo.add(layers.Conv2D(CONV2D_FILTERS_1, CONV2D_KERNEL_SIZE, activation='relu', input_shape=DIMENSAO_IMAGEM))
modelo.add(layers.MaxPooling2D(POOL_SIZE))


# Camada intermediária - Segundo bloco de convolução e max pooling
modelo.add(layers.Conv2D(CONV2D_FILTERS_2, CONV2D_KERNEL_SIZE, activation='relu'))
modelo.add(layers.MaxPooling2D(POOL_SIZE))


# Camada intermediária - Terceiro bloco de convolução e max pooling
modelo.add(layers.Conv2D(CONV2D_FILTERS_2, CONV2D_KERNEL_SIZE, activation='relu'))
modelo.add(layers.MaxPooling2D(POOL_SIZE))


# Camadas de classificação
modelo.add(layers.Flatten())
modelo.add(layers.Dense(DENSE_UNITS_1, activation='relu'))
modelo.add(layers.Dense(DENSE_UNITS_2, activation='softmax'))


# Informações sobre o modelo
modelo.summary()

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d (Conv2D)             (None, 30, 30, 32)        896       
                                                                 
 max_pooling2d (MaxPooling2D  (None, 15, 15, 32)       0         
 )                                                               
                                                                 
 conv2d_1 (Conv2D)           (None, 13, 13, 64)        18496     
                                                                 
 max_pooling2d_1 (MaxPooling  (None, 6, 6, 64)         0         
 2D)                                                             
                                                                 
 conv2d_2 (Conv2D)           (None, 4, 4, 64)          36928     
                                                                 
 max_pooling2d_2 (MaxPooling  (None, 2, 2, 64)         0         
 2D)                                                             
                                                                 
 flatten (Flatten)           (None, 256)               0         
                                                                 
 dense (Dense)               (None, 64)                16448     
                                                                 
 dense_1 (Dense)             (None, 10)                650       
                                                                 
=================================================================
Total params: 73,418
Trainable params: 73,418
Non-trainable params: 0
_________________________________________________________________


# Compilação do modelo
modelo.compile(optimizer = 'adam',
               loss = 'sparse_categorical_crossentropy',
               metrics = ['accuracy'])


# Treinamento do modelo
historico = modelo.fit(imagens_treino,
                       labels_treino,
                       epochs = 10,
                       validation_data = (imagens_teste, labels_teste))

UsageError: Line magic function `%%time` not found.


# Obtém métricas do modelo
erro_teste, acc_teste = modelo.evaluate(imagens_teste, labels_teste, verbose = 2)

313/313 - 5s - loss: 0.9509 - accuracy: 0.6760 - 5s/epoch - 15ms/step


# Exibe métricas do modelo
print('Acurácia do Modelo com Dados de Teste foi de ', round(acc_teste*100, 2), '%')

Acurácia do Modelo com Dados de Teste: 67.6 %


# Carrega imagem a partir de um arquivo
imagem_caminhao = Image.open('Caminhao_Optimus_Prime.png')


# Função para visualizar uma imagem
def visualizar_imagem(imagem, dimensao=DIMENSAO_IMAGEM[:2]):
    plt.figure(figsize = dimensao)
    plt.imshow(imagem)
    plt.xticks([])
    plt.yticks([])
    plt.show()


# Visualiza a imagem carregada
visualizar_imagem(imagem_caminhao)


# Função para redimensionar uma imagem para uso no modelo
def redimensionar_imagem(imagem, dimensao=DIMENSAO_IMAGEM[:2], normalizacao=VALOR_NORMALIZACAO_PIXEL):
    imagem = imagem.resize(dimensao)
    imagem_array = np.array(imagem) / normalizacao
    imagem_array = np.expand_dims(imagem_array, axis = 0)
    return imagem_array


# Redimensiona a imagem carregada
imagem_caminhao_array = redimensionar_imagem(imagem_caminhao)


# Predição para uma imagem não treinada
predicao = modelo.predict(imagem_caminhao_array);

1/1 [==============================] - 0s 47ms/step


# Exibição dos resultados da predição
classe_prevista = np.argmax(predicao)
nome_classe_prevista = classes[classe_prevista]
nome_classe_prevista_ptbr = traducao_classes[nome_classe_prevista]
print(f'A imagem foi classificada como: {nome_classe_prevista} ({nome_classe_prevista_ptbr}).' )

A imagem foi classificada como: truck (caminhão).

Exercício - Introdução a Deep Learning com TensorFlow¶

Sumário¶

1. Introdução¶

2. Objetivos¶

3. Desenvolvimento¶

3.1 Aquisição dos Dados¶

3.2 Pré-Processamento do Dados¶

3.3 Treinamento do Modelo¶

3.4 Avaliação do Modelo¶

3.5 Deploy do Modelo¶

4. Conclusão¶

Referências¶